/// @page ViewMechanisms Views
/// 
/// The views are used to display the model entities. They also depend on the controllers, by binding themselves to 
///	various signals that are triggered when various model operations occur. Depending on the purpose, there are 
///	different interfaces that a view should implement in order to display and to be notified on the changes of a 
///	specific CASE entity. For example, AbsUI::PackageView provides the interface that the views that display package 
///	related information should implement.
///
/// @section ViewMechanisms_MultiPurposeViews Multi-purpose Views
/// There are cases when a view display information related not only to a case entity of a specific type, but to a 
///	combination of case entity types (like it is the case of QtUI::ProjectTreeView, which displays project related 
///	information - the project name as the root node, and package related information - the package tree structure).
/// In this case, the view implementation use multiple inheritance and implements all the required interfaces.
/// 
/// @section ViewMechanisms_ReactionToModelChanges Reaction to Model Changes
/// When the views are created, the base classes, which also provide the interface of the views, also connect to the 
///	needed signals from the controller dealing with the CASE entity the view should display.
///
/// @subsection ViewMechanisms_QtIntegration QT Widgets Integration
/// The notification on model changes is done synchronously, as provided by boost::signals library. When integrating to 
///	QT Library, the handling should be done asynchronously, on the QT Thread. Since QT framework provides a way of 
///	connecting asynchronously, the views need an additional layer of connectivity.
/// @n
/// Basically, an implementation class is defined for the specific QT View base, providing a signal and a slot. This 
///	implementation class connects asynchronously each of its signals to the corresponding slot. The Qt View base class 
///	will own this implementation and provides additional virtual methods that need to be implemented by QT view 
///	specializations to handle the corresponding events. When a notification from controller is received, the handler 
///	defined by the abstract view will signal the implementation object about the event, which, in turn, calls the 
///	bounded slot asynchronously, and so the virtual method implementing the handling logic.
/// <br>
/// <b>Example: Project view base for QT</b>
/// @li The view is created using the constructor.
/// @li AbsUI::ProjectView::ProjectView constructor is called. It binds the handler 
///		AbsUI::ProjectView::projectChangeSlot( Model::Project*) to the signal for project changing.
/// @li The QtUI::QtProjectViewBase constructor is called. This constructor builds the implementation object as instance 
///		of QtUI::Impl::QtProjectViewImpl.
/// @li QtUI::Impl::QtProjectViewImpl binds the QtUI::Impl::QtProjectViewImpl::projectChangedSignal( Model::Project*) to 
///		the slot QtUI::Impl::QtProjectViewImpl::projectChangedSlot( Model::Project*)
/// 
/// While the application runs:
/// @li The project is changed.
/// @li The project controller signals that the project is changed.
/// @li AbsUI::ProjectView::projectChangeSlot( Model::Project*) is called.
/// @li AbsUI::ProjectView::projectChangeSlot( Model::Project*) calls AbsUI::ProjectView::changeProject( Model::Project*) 
///		virtual method, which actually means calling QtUI::QtProjectViewBase::changeProject( Model::Project*).
/// @li QtUI::QtProjectViewBase::changeProject( Model::Project*) emits the signal 
///		QtUI::Impl::QtProjectViewImpl::projectChangedSignal( Model::Project*) which calls 
///		QtUI::Impl::QtProjectViewImpl::projectChangedSlot( Model::Project*) asynchronously, on user interface thread.
/// @li QtUI::Impl::QtProjectViewImpl::projectChangedSlot( Model::Project*) calls 
///		QtUI::QtProjectViewBase::handleProjectChanged( Model::Project* pNewPrj) virtual methods, which actually means 
///		calling QtUI::ProjectTreeView::handleProjectChanged( Model::Project* pNewPrj).
/// @li QtUI::ProjectTreeView::handleProjectChanged( Model::Project* pNewPrj) performs the updates to the view.
///
/// @subsection ViewMechanisms_ChangingModel Changing Model from Views
/// The changes of the model from a view can be done by either using Ctrl::ControlCommand objects or user interface 
///	commands. 
/// <br>
/// For more information, see @ref ControlCommands "Control Commands", @ref QtUndoableCommands "Undoable Commands" or 
///	@ref UICommands "User Interface Commands".